home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / fire-man.swf / scripts / frame_589 / PlaceObject2_276_11 / CLIPACTIONRECORD onClipEvent(enterFrame).as next >
Encoding:
Text File  |  2011-10-17  |  12.1 KB  |  512 lines
  1. onClipEvent(enterFrame){
  2.    function hitPlatforms()
  3.    {
  4.       var u;
  5.       u = suelo = sueloI = sueloD = false;
  6.       i = -9;
  7.       while(i <= 0)
  8.       {
  9.          sueloI = sueloI || mapa.hitTest(_X + i,_Y,true);
  10.          i++;
  11.       }
  12.       i = 1;
  13.       while(i <= 9)
  14.       {
  15.          sueloD = sueloD || mapa.hitTest(_X + i,_Y,true);
  16.          i++;
  17.       }
  18.       if(sueloI && wallizq() && !sueloD && !techo)
  19.       {
  20.          return undefined;
  21.       }
  22.       if(sueloD && wallder() && !sueloI && !techo)
  23.       {
  24.          return undefined;
  25.       }
  26.       suelo = sueloI || sueloD;
  27.       if(suelo)
  28.       {
  29.          falling = false;
  30.          currenthigh = 0;
  31.          techo = false;
  32.          if(s)
  33.          {
  34.             landing.start();
  35.             s = false;
  36.          }
  37.          j = -15;
  38.          while(j <= 15)
  39.          {
  40.             i = -9;
  41.             while(i <= 9)
  42.             {
  43.                if(mapa.hitTest(_X + i,_Y + j,true) && !mapa.hitTest(_X + i,_Y + j - 1,true))
  44.                {
  45.                   u = true;
  46.                   break;
  47.                }
  48.                i++;
  49.             }
  50.             if(u)
  51.             {
  52.                break;
  53.             }
  54.             j++;
  55.          }
  56.          _Y = _Y + j;
  57.          j = vertical = 0;
  58.       }
  59.       return undefined;
  60.    }
  61.    function roof()
  62.    {
  63.       var u = techo = false;
  64.       i = -3;
  65.       while(i <= 3)
  66.       {
  67.          if(mapa.hitTest(_X + i,_Y - 30,true))
  68.          {
  69.             u = techo = true;
  70.             break;
  71.          }
  72.          i++;
  73.       }
  74.       return u;
  75.    }
  76.    function gridx(a)
  77.    {
  78.       return int(a / GRIDSIZE);
  79.    }
  80.    function gridy(b)
  81.    {
  82.       if(b >= 0)
  83.       {
  84.          return int(b / GRIDSIZE);
  85.       }
  86.       return Math.floor(b / GRIDSIZE);
  87.    }
  88.    function render()
  89.    {
  90.       if(!death)
  91.       {
  92.          scrollspeed = 0;
  93.          if(this.hitTest(_root.scrollmask))
  94.          {
  95.             doscroll = true;
  96.          }
  97.          if(_root.topeizq._x >= 0 && horizontal < 0 || _root.topeder._x <= 256 && horizontal > 0)
  98.          {
  99.             doscroll = false;
  100.          }
  101.          if(doscroll)
  102.          {
  103.             _X = lastX;
  104.             scrollspeed = setSpeed();
  105.          }
  106.          lastX = _X;
  107.          lastY = _Y;
  108.          if(!shooting && abletoshoot)
  109.          {
  110.             if(Key.isDown(SHOOT) && keys)
  111.             {
  112.                justshoot = true;
  113.                abletoshoot = false;
  114.             }
  115.             else
  116.             {
  117.                justshoot = false;
  118.             }
  119.          }
  120.          if(justshoot && !shooting)
  121.          {
  122.             if(_xscale > 0)
  123.             {
  124.                shoot1._x = _X + 41;
  125.             }
  126.             else
  127.             {
  128.                shoot1._x = _X - 41;
  129.             }
  130.             if(!vertical)
  131.             {
  132.                shoot1._y = _Y - 14;
  133.             }
  134.             else
  135.             {
  136.                shoot1._y = _Y - 20;
  137.             }
  138.             shoot1._visible = true;
  139.             if(_xscale > 0)
  140.             {
  141.                shoot1.dx = Math.abs(shoot1.dx);
  142.                shoot1._xscale = Math.abs(shoot1._xscale);
  143.             }
  144.             if(_xscale < 0)
  145.             {
  146.                shoot1.dx = Math.abs(shoot1.dx) * -1;
  147.                shoot1._xscale = Math.abs(shoot1._xscale) * -1;
  148.             }
  149.             blast.start();
  150.             shooting = true;
  151.             justshoot = false;
  152.          }
  153.          if(!shooting && !abletoshoot)
  154.          {
  155.             if(!Key.isDown(SHOOT))
  156.             {
  157.                abletoshoot = true;
  158.             }
  159.          }
  160.          x = setSpeed();
  161.          if(!flashing)
  162.          {
  163.             horizontal = x;
  164.          }
  165.          if(vertical == 0 && Key.isDown(ARRIBA) && upreleased && keys)
  166.          {
  167.             vertical = vforce * -1;
  168.             horizontal += platform.dx;
  169.             platformscroll = 0;
  170.             rising = true;
  171.             upreleased = false;
  172.             salto.start();
  173.          }
  174.          if(!falling && !uprelease)
  175.          {
  176.             if(!Key.isDown(ARRIBA))
  177.             {
  178.                upreleased = true;
  179.             }
  180.          }
  181.          if(rising)
  182.          {
  183.             if(roof())
  184.             {
  185.                falling = true;
  186.                startfall = true;
  187.                rising = false;
  188.             }
  189.             if(currenthigh < MAXJUMP && Key.isDown(ARRIBA) && !upreleased && !flashing)
  190.             {
  191.                if(roof())
  192.                {
  193.                   startfall = true;
  194.                   falling = true;
  195.                   rising = false;
  196.                }
  197.                if(currenthigh < vforcei)
  198.                {
  199.                   vertical = - Math.abs(vforcei);
  200.                }
  201.                else
  202.                {
  203.                   vertical = - Math.abs(vforce);
  204.                }
  205.                currenthigh += Math.abs(vertical);
  206.             }
  207.             else
  208.             {
  209.                vertical *= gravity;
  210.                currenthigh += Math.abs(vertical);
  211.                if(Math.abs(vertical) < 1)
  212.                {
  213.                   startfall = true;
  214.                   falling = true;
  215.                   rising = false;
  216.                }
  217.             }
  218.          }
  219.          if(Key.isDown(SLIDEKEY) && !rising && !falling && keys && slidereleased)
  220.          {
  221.             if(_xscale < 0 && !wallizq())
  222.             {
  223.                slideLeft = true;
  224.                slideRight = false;
  225.             }
  226.             if(_xscale > 0 && !wallder())
  227.             {
  228.                slideLeft = false;
  229.                slideRight = true;
  230.             }
  231.             slide = slideLeft || slideRight;
  232.             slidereleased = false;
  233.          }
  234.          if(slide && slidetimer == 0)
  235.          {
  236.             slidetimer = SLIDETIME;
  237.          }
  238.          if(slide && slidetimer > 0)
  239.          {
  240.             slidetimer--;
  241.             if(slidetimer == 0 || Key.isDown(IZQ) && slideRight || Key.isDown(DER) && slideLeft || falling || wallizq() && slideLeft || wallder() && slideRight)
  242.             {
  243.                slide = slideLeft = slideRight = slidetimer = 0;
  244.             }
  245.          }
  246.          if(!Key.isDown(SLIDEKEY) && !slidereleased)
  247.          {
  248.             slidereleased = true;
  249.          }
  250.          if(falling)
  251.          {
  252.             s = true;
  253.             if(startfall)
  254.             {
  255.                vertical = Math.abs(vforcei / 2) * accel;
  256.                startfall = false;
  257.             }
  258.             else
  259.             {
  260.                vertical = Math.abs(vertical) * accel;
  261.             }
  262.             if(vertical > MAXVERTICAL)
  263.             {
  264.                vertical = MAXVERTICAL;
  265.             }
  266.             platformscroll = 0;
  267.             hitPlatforms();
  268.             if(_Y >= 245)
  269.             {
  270.                death = true;
  271.                _root.fdeath.start();
  272.             }
  273.          }
  274.          if(tornado)
  275.          {
  276.             floating = true;
  277.             playtornado = true;
  278.             vertical2 += vforce;
  279.             if(vertical2 > MAXVERTICAL)
  280.             {
  281.                vertical2 = MAXVERTICAL / 6;
  282.             }
  283.          }
  284.          else
  285.          {
  286.             playtornado = false;
  287.          }
  288.          if(floating && !rising)
  289.          {
  290.             if(tornado)
  291.             {
  292.                vertical = - vertical2;
  293.             }
  294.             else
  295.             {
  296.                vertical = -4;
  297.                floating = false;
  298.                rising = true;
  299.                vertical2 = 0;
  300.             }
  301.          }
  302.          if(playtornado && !soundtrigged)
  303.          {
  304.             _root.wind04.setVolume(100);
  305.             _root.wind04.start();
  306.             u = 100;
  307.             soundtrigged = true;
  308.          }
  309.          if(soundtrigged && !playtornado && u > 0)
  310.          {
  311.             u -= 5;
  312.             _root.wind04.setVolume(u);
  313.             if(u == 0)
  314.             {
  315.                _root.wind04.stop();
  316.                playtornado = true;
  317.                soundtrigged = false;
  318.             }
  319.          }
  320.          tornado = false;
  321.          if(_root.windx)
  322.          {
  323.             horizontal += _root.windx;
  324.          }
  325.          _Y = _Y + vertical + platform.dy;
  326.          if(horizontal < 0 && !wallizq() || horizontal > 0 && !wallder())
  327.          {
  328.             _X = _X + horizontal;
  329.          }
  330.          drawframe();
  331.          x1 = LastX - platform._x;
  332.          x2 = _X - platform._x;
  333.          if(!falling && !rising)
  334.          {
  335.             hitPlatforms();
  336.             if(!suelo)
  337.             {
  338.                vertical = 2;
  339.                falling = true;
  340.             }
  341.          }
  342.       }
  343.       else
  344.       {
  345.          drawframe();
  346.          vertical = horizontal = doscroll = scrollspeed = 0;
  347.          if(!f)
  348.          {
  349.             _root.fade.begin = true;
  350.             f = true;
  351.          }
  352.       }
  353.    }
  354.    function wallizq()
  355.    {
  356.       var u = false;
  357.       var t = !slide ? 12 : 20;
  358.       i = -24;
  359.       while(i < -15)
  360.       {
  361.          if(mapa.hitTest(_X - t,_Y + i,true))
  362.          {
  363.             u = true;
  364.             break;
  365.          }
  366.          i++;
  367.       }
  368.       return u;
  369.    }
  370.    function wallder()
  371.    {
  372.       var u = false;
  373.       var t = !slide ? 12 : 20;
  374.       i = -24;
  375.       while(i < -15)
  376.       {
  377.          if(mapa.hitTest(_X + t,_Y + i,true))
  378.          {
  379.             u = true;
  380.             break;
  381.          }
  382.          i++;
  383.       }
  384.       return u;
  385.    }
  386.    function setSpeed()
  387.    {
  388.       if(slideLeft && !rising)
  389.       {
  390.          forward = true;
  391.          backward = false;
  392.          if(horizontal == 0)
  393.          {
  394.             return hforce * -1;
  395.          }
  396.          return hforce * -1.5;
  397.       }
  398.       if(slideRight && !rising)
  399.       {
  400.          forward = false;
  401.          backward = true;
  402.          if(horizontal == 0)
  403.          {
  404.             return hforce;
  405.          }
  406.          return hforce * 1.5;
  407.       }
  408.       if(Key.isDown(DER) && keys && !wallder())
  409.       {
  410.          forward = false;
  411.          backward = true;
  412.          if(horizontal == 0)
  413.          {
  414.             return hforcei;
  415.          }
  416.          return hforce;
  417.       }
  418.       if(Key.isDown(IZQ) && keys && !wallizq())
  419.       {
  420.          forward = true;
  421.          backward = false;
  422.          if(horizontal == 0)
  423.          {
  424.             return hforcei * -1;
  425.          }
  426.          return hforce * -1;
  427.       }
  428.       return 0;
  429.    }
  430.    function drawFrame()
  431.    {
  432.       if(victory)
  433.       {
  434.          this.gotoAndStop("victory");
  435.          return undefined;
  436.       }
  437.       if(death)
  438.       {
  439.          this.gotoAndStop("death");
  440.          return undefined;
  441.       }
  442.       if(flashing)
  443.       {
  444.          this.gotoAndStop("hitted");
  445.          return undefined;
  446.       }
  447.       if(lastX != _X)
  448.       {
  449.          !forward ? (_xscale = Math.abs(_xscale)) : (_xscale = Math.abs(_xscale) * -1);
  450.       }
  451.       if(!shooting)
  452.       {
  453.          if(lastY > _Y && rising)
  454.          {
  455.             this.gotoAndStop("jump");
  456.             _root.estado = 3;
  457.             return undefined;
  458.          }
  459.       }
  460.       else if(lastY > _Y && rising)
  461.       {
  462.          this.gotoAndStop("attackJ");
  463.          _root.estado = 4;
  464.          return undefined;
  465.       }
  466.       if(lastY < _Y && falling || floating)
  467.       {
  468.          this.gotoAndStop("fall");
  469.          _root.estado = 5;
  470.          return undefined;
  471.       }
  472.       if(slide)
  473.       {
  474.          this.gotoAndStop("slide");
  475.          _root.estado = 6;
  476.          return undefined;
  477.       }
  478.       if(shooting)
  479.       {
  480.          if(!horizontal)
  481.          {
  482.             this.gotoAndStop("attackST");
  483.             return undefined;
  484.          }
  485.          if(horizontal)
  486.          {
  487.             this.gotoAndStop("attackRU");
  488.             sprite.gotoAndPlay(frame);
  489.             _root.estado = 2;
  490.             return undefined;
  491.          }
  492.       }
  493.       else
  494.       {
  495.          if(!horizontal)
  496.          {
  497.             this.gotoAndStop("standing");
  498.             _root.estado = 0;
  499.             return undefined;
  500.          }
  501.          if(horizontal)
  502.          {
  503.             this.gotoAndStop("run");
  504.             _root.estado = 1;
  505.             return undefined;
  506.          }
  507.       }
  508.    }
  509.    render();
  510.    frame = sprite._currentframe;
  511. }
  512.